/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { ChronoField, Period, ChronoUnit, TemporalAdjusters, LocalDate, LocalTime, ZoneOffset, LocalDateTime, DateTimeFormatter } from './js-joda/core/dist/js-joda.esm.js'



const nowDate = LocalDate.now()
const mDate = LocalDate.parse('2022-07-21')
const mTime = LocalTime.parse('23:55:42.123')
const mTime1 = LocalTime.parse("11:55:42");
const mTime2 = mTime1.plusHours(2);
const mTime3 = mTime1.plusHours(2).plusMinutes(42).plusSeconds(12);

function now_DateTest() {
  const date = new Date();
  const result = date.toISOString().slice(0, 10);
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = LocalDate.now();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.now error'
  }
  print(`js-joda_LocalDate.now: ${endTime - startTime} ms`)
}


function parse_DateTest() {
  let result = '2022-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 10000; i++) {
    resultDate = LocalDate.parse("2022-07-21");
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.parse error'
  }
  print(`js-joda_LocalDate.parse: ${endTime - startTime} ms`)
}


function dayOfMonth_DateTest() {
  let result = '21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.dayOfMonth();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.dayOfMonth error'
  }
  print(`js-joda_dayOfMonth: ${endTime - startTime} ms`)
}

function month_DateTest() {
  let result = 'JULY'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.month();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.month error'
  }
  print(`js-joda_month: ${endTime - startTime} ms`)
}

function monthValue_DateTest() {
  let result = '7'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.monthValue();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.monthValue error'
  }
  print(`js-joda_monthValue: ${endTime - startTime} ms`)
}

function year_DateTest() {
  let result = '2022'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.year();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.year error'
  }
  print(`js-joda_year: ${endTime - startTime} ms`)
}

function dayOfWeek_DateTest() {
  let result = 'THURSDAY'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 500000; i++) {
    resultDate = mDate.dayOfWeek();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.dayOfWeek error'
  }
  print(`js-joda_dayOfWeek: ${endTime - startTime} ms`)
}

function dayOfYear_DateTest() {
  let result = '202'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 500000; i++) {
    resultDate = mDate.dayOfYear();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.dayOfYear error'
  }
  print(`js-joda_dayOfYear: ${endTime - startTime} ms`)
}

function isLeapYear_DateTest() {
  let result = 'false'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.isLeapYear();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.isLeapYear error'
  }
  print(`js-joda_isLeapYear: ${endTime - startTime} ms`)
}

function lengthOfMonth_DateTest() {
  let result = '31'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.lengthOfMonth();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.lengthOfMonth error'
  }
  print(`js-joda_lengthOfMonth: ${endTime - startTime} ms`)
}


function lengthOfYear_DateTest() {
  let result = '365'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.lengthOfYear();
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.lengthOfYear error'
  }
  print(`js-joda_lengthOfYear: ${endTime - startTime} ms`)
}

function get_DateTest() {
  let result = '29'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 1000000; i++) {
    resultDate = mDate.get(ChronoField.ALIGNED_WEEK_OF_YEAR);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.get error'
  }
  print(`js-joda_mDate.get: ${endTime - startTime} ms`)
}

function plusDays_DateTest() {
  let result = '2023-07-22'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.plusDays(366);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.plusDays error'
  }
  print(`js-joda_plusDays: ${endTime - startTime} ms`)
}

function minusDays_DateTest() {
  let result = '2021-07-20'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.minusDays(366);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.minusDays error'
  }
  print(`js-joda_minusDays: ${endTime - startTime} ms`)
}

function plusMonths_DateTest() {
  let result = '2023-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.plusMonths(12);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.plusMonths error'
  }
  print(`js-joda_plusMonths: ${endTime - startTime} ms`)
}

function minusMonths_DateTest() {
  let result = '2021-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.minusMonths(12);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.minusMonths error'
  }
  print(`js-joda_minusMonths: ${endTime - startTime} ms`)
}

function plusWeeks_DateTest() {
  let result = '2022-08-18'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.plusWeeks(4);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.plusWeeks error'
  }
  print(`js-joda_plusWeeks: ${endTime - startTime} ms`)
}

function minusWeeks_DateTest() {
  let result = '2022-06-23'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.minusWeeks(4);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.minusWeeks error'
  }
  print(`js-joda_minusWeeks: ${endTime - startTime} ms`)
}

function plusYears_DateTest() {
  let result = '2023-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.plusYears(1);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.plusYears error'
  }
  print(`js-joda_plusYears: ${endTime - startTime} ms`)
}

function minusYears_DateTest() {
  let result = '2021-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.minusYears(1);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.minusYears error'
  }
  print(`js-joda_minusYears: ${endTime - startTime} ms`)
}

function plus_DateTest() {
  let result = '2022-08-24'
  let resultDate = null;
  let startTime = Date.now();
  const period = Period.ofMonths(1).plusDays(3)
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.plus(period);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.plus error'
  }
  print(`js-joda_plus: ${endTime - startTime} ms`)
}

function minus_DateTest() {
  let result = '2022-06-18'
  let resultDate = null;
  let startTime = Date.now();
  const period = Period.ofMonths(1).plusDays(3)
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.minus(period);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.minus error'
  }
  print(`js-joda_minus: ${endTime - startTime} ms`)
}

function withDayOfMonth_DateTest() {
  let result = '2022-07-01'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.withDayOfMonth(1);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.withDayOfMonth error'
  }
  print(`js-joda_withDayOfMonth: ${endTime - startTime} ms`)
}

function withMonth_DateTest() {
  let result = '2022-01-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.withMonth(1);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.withMonth error'
  }
  print(`js-joda_withMonth: ${endTime - startTime} ms`)
}

function withYear_DateTest() {
  let result = '2000-07-21'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.withYear(2000);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.withYear error'
  }
  print(`js-joda_withYear: ${endTime - startTime} ms`)
}

function withDayOfYear_DateTest() {
  let result = '2022-02-11'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.withDayOfYear(42);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.withDayOfYear error'
  }
  print(`js-joda_withDayOfYear: ${endTime - startTime} ms`)
}

function isAfter_DateTest() {
  let result = 'false'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.isAfter(nowDate);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.isAfter error'
  }
  print(`js-joda_isAfter: ${endTime - startTime} ms`)
}

function isBefore_DateTest() {
  let result = 'true'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.isBefore(nowDate);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.isBefore error'
  }
  print(`js-joda_isBefore: ${endTime - startTime} ms`)
}

function equals_DateTest() {
  let result = 'false'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultDate = mDate.equals(nowDate);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.equals error'
  }
  print(`js-joda_equals: ${endTime - startTime} ms`)
}

function until_DateTest() {
  const newDate = mDate.plusDays(2)
  let result = 'P2D'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 50000; i++) {
    resultDate = mDate.until(newDate);
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.until error'
  }
  print(`js-joda_until: ${endTime - startTime} ms`)
}

function with_DateTest() {
  let result = '2022-07-01'
  let resultDate = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultDate = mDate.with(TemporalAdjusters.firstDayOfMonth());
  }
  let endTime = Date.now();
  if (resultDate.toString() != result) {
    throw 'LocalDate.with error'
  }
  print(`js-joda_with: ${endTime - startTime} ms`)
}

function now_TimeTest() {
  const time = new Date()
  const result = time.getHours();
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = LocalTime.now(ZoneOffset.UTC8);
  }
  let endTime = Date.now();
  if (resultTime.hour() != result) {
    throw 'LocalTime.now error'
  }
  print(`js-joda_LocalTime.now: ${endTime - startTime} ms`)
}

function of_TimeTest() {
  const result = '23:55:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = LocalTime.of(23, 55, 42);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.of error'
  }
  print(`js-joda_LocalTime.of: ${endTime - startTime} ms`)
}

function ofSecondOfDay_TimeTest() {
  const result = '01:01:06';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = LocalTime.ofSecondOfDay(3666);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.ofSecondOfDay error'
  }
  print(`js-joda_LocalTime.ofSecondOfDay: ${endTime - startTime} ms`)
}

function parse_TimeTest() {
  const result = '23:55:42.123';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = LocalTime.parse('23:55:42.123');
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.parse error'
  }
  print(`js-joda_LocalTime.parse: ${endTime - startTime} ms`)
}

function truncatedTo_TimeTest() {
  const result = '23:55:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime.truncatedTo(ChronoUnit.SECONDS);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.truncatedTo error'
  }
  print(`js-joda_truncatedTo: ${endTime - startTime} ms`)
}

function hour_TimeTest() {
  const result = '23';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime.hour();
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.hour error'
  }
  print(`js-joda_hour: ${endTime - startTime} ms`)
}

function minute_TimeTest() {
  const result = '55';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime.minute();
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.minute error'
  }
  print(`js-joda_minute: ${endTime - startTime} ms`)
}

function second_TimeTest() {
  const result = '42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime.second();
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.second error'
  }
  print(`js-joda_second: ${endTime - startTime} ms`)
}

function nano_TimeTest() {
  const result = '123000000';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime.nano();
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.nano error'
  }
  print(`js-joda_nano: ${endTime - startTime} ms`)
}

function get_TimeTest() {
  const result = '86142';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 1000000; i++) {
    resultTime = mTime.get(ChronoField.SECOND_OF_DAY);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.get01 error'
  }
  print(`js-joda_mTime.get: ${endTime - startTime} ms`)
}

function plusHours_TimeTest() {
  const result = '23:55:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.plusHours(12);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.plusHours error'
  }
  print(`js-joda_plusHours: ${endTime - startTime} ms`)
}

function plusMinutes_TimeTest() {
  const result = '12:25:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.plusMinutes(30);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.plusMinutes error'
  }
  print(`js-joda_plusMinutes: ${endTime - startTime} ms`)
}

function plusSeconds_TimeTest() {
  const result = '11:56:12';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.plusSeconds(30);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.plusSeconds error'
  }
  print(`js-joda_plusSeconds: ${endTime - startTime} ms`)
}

function plusNanos_TimeTest() {
  const result = '11:55:42.001';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.plusNanos(1000000);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.plusNanos error'
  }
  print(`js-joda_plusNanos: ${endTime - startTime} ms`)
}

function plus_TimeTest() {
  const result = '11:55:42.001';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.plus(1, ChronoUnit.MILLIS);
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.plus error'
  }
  print(`js-joda_mTime.plus: ${endTime - startTime} ms`)
}

function withHour_TimeTest() {
  const result = '01:55:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.withHour(1)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.withHour error'
  }
  print(`js-joda_withHour: ${endTime - startTime} ms`)
}

function withMinute_TimeTest() {
  const result = '11:01:42';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.withMinute(1)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.withMinute error'
  }
  print(`js-joda_withMinute: ${endTime - startTime} ms`)
}

function withSecond_TimeTest() {
  const result = '11:55:01';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 100000; i++) {
    resultTime = mTime1.withSecond(1)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.withSecond error'
  }
  print(`js-joda_withSecond: ${endTime - startTime} ms`)
}

function isAfter_TimeTest() {
  const result = 'false';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime1.isAfter(mTime2)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.isAfter error'
  }
  print(`js-joda_mTime.isAfter: ${endTime - startTime} ms`)
}

function isBefore_TimeTest() {
  const result = 'true';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 5000000; i++) {
    resultTime = mTime1.isBefore(mTime2)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.isBefore error'
  }
  print(`js-joda_mTime.isBefore: ${endTime - startTime} ms`)
}

function until_TimeTest() {
  const result = '9732';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 50000; i++) {
    resultTime = mTime1.until(mTime3, ChronoUnit.SECONDS)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalTime.until error'
  }
  print(`js-joda_mtime.until: ${endTime - startTime} ms`)
}

function parse_Test() {
  const result = '2018-04-28T12:34';
  let resultTime = null;
  let startTime = Date.now();
  for (let i = 0; i < 10000; i++) {
    resultTime = LocalDateTime.parse('2018-04-28T12:34')
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'LocalDateTime.parse error'
  }
  print(`js-joda_LocalDateTime.parse: ${endTime - startTime} ms`)
}


function format_Test() {
  const result = '4/28/2018 12:34';
  const dateTime = LocalDateTime.parse('2018-04-28T12:34')
  let resultTime = null;
  let startTime = Date.now();
  const formatStr = DateTimeFormatter.ofPattern('M/d/yyyy HH:mm')
  for (let i = 0; i < 100000; i++) {
    resultTime = dateTime.format(formatStr)
  }
  let endTime = Date.now();
  if (resultTime.toString() != result) {
    throw 'Formatter.format01 error'
  }
  print(`js-joda_format: ${endTime - startTime} ms`)
}


  now_DateTest()
  parse_DateTest()
  dayOfMonth_DateTest()
  month_DateTest()
  monthValue_DateTest()
  year_DateTest()
  dayOfWeek_DateTest()
  dayOfYear_DateTest()
  isLeapYear_DateTest()
  lengthOfMonth_DateTest()
  lengthOfYear_DateTest()
  get_DateTest()
  plusDays_DateTest()
  minusDays_DateTest()
  plusMonths_DateTest()
  minusMonths_DateTest()
  plusWeeks_DateTest()
  minusWeeks_DateTest()
  plusYears_DateTest()
  minusYears_DateTest()
  plus_DateTest()
  minus_DateTest()
  withDayOfMonth_DateTest()
  withMonth_DateTest()
  withYear_DateTest()
  withDayOfYear_DateTest()
  isAfter_DateTest()
  isBefore_DateTest()
  equals_DateTest()
  until_DateTest()
  with_DateTest()
  now_TimeTest()
  of_TimeTest()
  ofSecondOfDay_TimeTest()
  parse_TimeTest()
  truncatedTo_TimeTest()
  hour_TimeTest()
  minute_TimeTest()
  second_TimeTest()
  nano_TimeTest()
  get_TimeTest()
  plusHours_TimeTest()
  plusMinutes_TimeTest()
  plusSeconds_TimeTest()
  plusNanos_TimeTest()
  plus_TimeTest()
  withHour_TimeTest()
  withMinute_TimeTest()
  withSecond_TimeTest()
  isAfter_TimeTest()
  isBefore_TimeTest()
  until_TimeTest()
  parse_Test()
  format_Test()
